package com.mcp.converter.domain.rule.compatibility.function;

import com.mcp.converter.domain.checker.IncompatibilityDetail;
import com.mcp.converter.shared.response.sql.SQLElement;
import com.mcp.converter.domain.rule.compatibility.AbstractFunctionRule;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

/**
 * 正则表达式函数兼容性规则
 * OceanBase中正则表达式函数的语法和选项与Oracle有差异
 * @author zengxiong
 */
public class RegexpFunctionRule extends AbstractFunctionRule {
    private static final String RULE_ID = "FN011";
    private static final String RULE_NAME = "正则表达式函数差异";
    private static final String RULE_DESCRIPTION = "OceanBase中正则表达式函数的语法和选项与Oracle存在差异";

    private static final Set<String> REGEXP_FUNCTIONS = new HashSet<>(Arrays.asList(
        "REGEXP_LIKE"
    ));

    private static final Logger log = LoggerFactory.getLogger(RegexpFunctionRule.class);

    public RegexpFunctionRule() {
        super(RULE_ID, RULE_NAME, RULE_DESCRIPTION);
        setIncompatibilityDetail(
            "OceanBase中REGEXP_LIKE函数在以下方面与Oracle存在差异：\n" +
            "1. REGEXP_LIKE:\n" +
            "   - 正则表达式语法支持程度不同\n" +
            "   - 匹配选项参数的处理差异\n" +
            "   - 某些高级正则特性可能不支持",
            "可能导致：\n" +
            "1. 正则表达式匹配结果不一致\n" +
            "2. 复杂正则模式执行失败",
            "建议：\n" +
            "1. 使用基本的正则表达式语法，避免使用高级特性\n" +
            "2. 明确指定所有可选参数，不依赖默认值\n" +
            "3. 对多字节字符的处理进行特别测试\n" +
            "4. 考虑使用简单的字符串函数作为替代\n" +
            "5. 建立完整的测试用例覆盖各种匹配情况",
            IncompatibilityDetail.Severity.MEDIUM
        );
    }

    @Override
    public boolean matches(Object target) {
        log.debug("[RegexpFunctionRule] 开始匹配检查");
        
        if (!(target instanceof SQLElement)) {
            log.debug("[RegexpFunctionRule] 目标对象不是SQLElement类型");
            return false;
        }

        SQLElement element = (SQLElement) target;
        log.info("[RegexpFunctionRule] 检查SQL元素: type={}, name={}, value={}", 
            element.getType(), element.getName(), element.getValue());

        if (!isFunctionElement(element)) {
            log.debug("[RegexpFunctionRule] 元素不是函数类型");
            return false;
        }

        String functionName = element.getName().toUpperCase().trim();
        log.info("[RegexpFunctionRule] 正在检查函数名: {}", functionName);
        
        boolean match = REGEXP_FUNCTIONS.contains(functionName);
        log.info("[RegexpFunctionRule] 函数匹配结果: name={}, match={}, supportedFunctions={}", 
            functionName, match, REGEXP_FUNCTIONS);
        
        if (match) {
            log.warn("[RegexpFunctionRule] 发现不兼容的正则表达式函数: {}", functionName);
            // 添加更详细的不兼容信息
            String detailMessage = String.format(
                "检测到不兼容的正则表达式函数 %s，该函数在OceanBase中的实现与Oracle存在差异。\n" +
                "SQL元素值: %s", 
                functionName, 
                element.getValue()
            );
            log.warn("[RegexpFunctionRule] 不兼容详情: {}", detailMessage);
        }

        return match;
    }
    
    @Override
    public Set<String> getIncompatibleFunctions() {
        return new HashSet<>(REGEXP_FUNCTIONS);
    }
}
